home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / CRS / crs20.d81 / fracland.sfx / fractal.hrland.c < prev   
Text File  |  1990-02-12  |  10KB  |  353 lines
  1. /* ╨ROGRAM: FRACTAL.HRLAND       ┴UTHOR: ╨AUL ╫. ├ARLSON
  2.  *
  3.  * ╘HIS PROGRAM PLOTS RANDOM FRACTAL LANDSCAPES IN HIRES
  4.  * MODE ON THE ├64.  ├OMPILED WITH THE ╨OWER ├ COMPILER.
  5.  */
  6.  
  7. #DEFINE ╠┴╬─   1
  8. #DEFINE ╫┴╘┼╥  2
  9. #DEFINE ╙╦┘    3
  10.  
  11. /* ╟LOBAL VARIABLES - ONLY MASK, COLOR, AND ODD ARE USED OUTSIDE OF
  12.  * THE MAIN FUNCTION.  ╘HE OTHERS ARE DECLARED GLOBAL FOR MEMORY
  13.  * ALLOCATION PURPOSES ONLY.
  14.  */
  15. UNSIGNED 
  16.    MASK[320]; /* MASK FOR HIDDEN LINE REMOVAL                     */
  17. INT 
  18.    H[65][65]; /* HEIGHT OR ELEVATION ABOVE SEA LEVEL              */
  19. UNSIGNED 
  20.    COLOR,     /* PIXEL COLOR                                      */
  21.    FMAX,      /* MAX. ELEVATION                                   */
  22.    SEED,      /* SEED FOR RANDOM NUMBER GENERATOR                 */
  23.    X;         /* DISTANCE ALONG X-AXIS                            */
  24. INT   
  25.    Z,         /* ELEVATION ABOVE SEA LEVEL                        */
  26.    ZP,        /* PREVIOUS ELEVATION ABOVE SEA LEVEL               */
  27.    ODD,       /* 1 FOR ODD NUMBERED CROSS-SECTIONS, 0 FOR EVEN    */
  28.    FIRST;     /* 1 IF FIRST POINT ON CROSS-SECTION, ELSE 0        */
  29.  
  30. /*============ ╞UNCTION: MAIN =====================================*/
  31. MAIN()
  32. █
  33.   UNSIGNED I1, I2, J1, J2,   /* INDEXES FOR NODES AT CORNERS       */
  34.       DELTA,   /* DIFFERENCE IN INDEXES FOR NODES AT ENDS OF SIDE  */
  35.       IM, JM,  /* INDEXES OF NODE AT MIDPOINT OF SIDE              */
  36.       I,       /* CROSS-SECTION NUMBER                             */
  37.       J,       /* SEGMENT NUMBER                                   */
  38.       BX, BY,  /* X,Y COORDINATES OF BEGINNING OF LINE SEGMENT     */
  39.       EX, EY,  /* X,Y COORDINATES OF END OF LINE SEGMENT           */
  40.       N;       /* LOOP COUNTER                                     */
  41.   CHAR  *VPTR, ASEED[6], C, GETKEY();
  42.  
  43.   HIGHMEM(35840);
  44.   TEXTMODE(11, 1, 11);
  45.   PRINTF("%C%C%C", 147, 14, 5);
  46.   PRINTF("\N           ╞RACTAL ╠ANDSCAPES\N");
  47.   PRINTF("          ┴UTHOR: ╨AUL ├ARLSON\N\N\N");
  48.   PRINTF("╔T TAKES ABOUT ONE MINUTE TO COMPUTE THE");
  49.   PRINTF("ELEVATIONS FOR EACH LANDSCAPE.  ╫HEN A  ");
  50.   PRINTF("LANDSCAPE IS COMPLETE, PRESS ╥┼╘╒╥╬.\N\N\N\N");
  51.   PRINTF("        ╨RESS ANY KEY TO BEGIN...");
  52.   GETKEY();
  53.  
  54.   /*------- MAIN LOOP - LOOP UNTIL A ZERO SEED IS ENTERED --------*/
  55.  
  56.   WHILE (1)
  57.   █ 
  58.     TEXTMODE(11, 1, 11);
  59.     PRINTF("%C%C%C", 147, 14, 5);  
  60.     PRINTF("┼NTER SEED FOR RANDOM NUMBER GENERATOR\N");
  61.     PRINTF("   (1 TO 32767, OR 0 TO QUIT): ");
  62.     GETS(ASEED);
  63.     SEED = ATOI(ASEED);
  64.     IF (!SEED) BREAK;
  65.     SRANDOM(SEED);
  66.     PRINTF("\N├OMPUTING ELEVATIONS...");
  67.     FOR (N = 0; N < 320; N++) MASK[N] = 200;
  68.     
  69.     /*------------- COMPUTE HEIGHTS AT ALL NODES -----------------*/
  70.     
  71.     FMAX = 0;
  72.     FOR (DELTA = 64; DELTA >= 2; DELTA >>= 1)
  73.     █ J1 = 0;
  74.       FOR (J2 = DELTA; J2 <= 64; J1 += DELTA, J2 += DELTA)
  75.       █ I1 = 0;
  76.         JM = (J1 + J2)>>1;  /* GET MIDPOINT J INDEX */
  77.         FOR (I2 = DELTA; I2 <= 64; I1 += DELTA, I2 += DELTA)
  78.         █ IM = (I1 + I2)>>1;  /* GET MIDPOINT I INDEX */
  79.           H[J1][IM] = (H[J1][I1] + H[J1][I2]) / 2 + RANDM(DELTA);
  80.           H[J2][IM] = (H[J2][I1] + H[J2][I2]) / 2 + RANDM(DELTA);
  81.           IF (I1) /* IF NOT THE BOTTOM EDGE OF PLOT... */
  82.             H[JM][I1] = (H[J1][I1] + H[J2][I1]) / 2 + RANDM(DELTA);
  83.           H[JM][I2] = (H[J1][I2] + H[J2][I2]) / 2 + RANDM(DELTA);
  84.           IF (RANDOM() & 1)  /* PICK DIAGONAL RANDOMLY */
  85.             H[JM][IM] = (H[J1][I1] + H[J2][I2] + 3 * RANDM(DELTA))/2;
  86.           ELSE 
  87.             H[JM][IM] = (H[J2][I1] + H[J1][I2] + 3 * RANDM(DELTA))/2;
  88.         ▌
  89.       ▌
  90.     ▌
  91.     /*---------------- SMOOTH THE HEIGHTS -------------------------*/
  92.     
  93.     FOR (I = 0; I <= 64; I++)
  94.       FOR (J = 1; J < 64; J++)
  95.         H[J][I] = (H[J-1][I] + H[J][I] + H[J+1][I]) / 3;
  96.     
  97.     /*------------------- DRAW BORDER -----------------------------*/
  98.     HIRES(11, 1, 11);
  99.     FOR (N = 0; N < 317; N++) 
  100.     █ PIXEL(N, 0);
  101.       PIXEL(N, 198);
  102.     ▌
  103.     FOR (N = 0; N < 199; N++) 
  104.     █ PIXEL(0, N);
  105.       PIXEL(316, N);
  106.     ▌
  107.     
  108.     /*------ DISPLAY THE PLOT, REMOVING HIDDEN LINES --------------*/
  109.     
  110.     FOR (I = 0; I <= 64; I++)
  111.     █ ODD = 0;
  112.       FOR (N = 0; N < 2; N++)
  113.       █ ZP = 0;
  114.         FIRST = 1;
  115.         IF (I == 64 && ODD) BREAK;
  116.         FOR (J = 0; J < 64; J ++)
  117.         █ X = 5 * J;
  118.  
  119.           /*-------- INTERPOLATE TO GET HEIGHTS ON ODD SECTIONS -----
  120.                      AND ADJUST IF GOING INTO OR COMING OUT OF
  121.                      THE WATER.                                    */
  122.  
  123.           IF (J && J < 63 && I < 64)
  124.           █ IF (ODD) /* THEN INTERPOLATE */
  125.             █ IF (H[J-1][I] + H[J-1][I+1] > 0 &&       /* ENTERING */
  126.                   H[J][I] + H[J][I+1] < 0)             /*    WATER */
  127.                 X += 5 * (H[J][I] + H[J][I+1]) / 
  128.                         (H[J-1][I] + H[J-1][I+1] - 
  129.                              H[J][I] - H[J][I+1]);
  130.               ELSE
  131.                 IF (H[J+1][I] + H[J+1][I+1] > 0 &&      /* LEAVING */
  132.                     H[J][I] + H[J][I+1] < 0)            /*   WATER */
  133.                   X += 5 * (H[J][I] + H[J][I+1]) /
  134.                           (H[J][I] + H[J][I+1] - 
  135.                               H[J+1][I] - H[J+1][I+1]);
  136.             ▌
  137.             ELSE /* DON'T INTERPOLATE */
  138.             █ IF (H[J-1][I] > 0 && H[J][I] < 0)  /* ENTERING WATER */
  139.                 X += 5 * H[J][I] / (H[J-1][I] - H[J][I]);
  140.               ELSE 
  141.                 IF (H[J+1][I] > 0 && H[J][I] < 0) /* LEAVING WATER */
  142.                   X += 5 * H[J][I] / (H[J][I] - H[J+1][I]);
  143.             ▌
  144.           ▌
  145.           IF (ODD) Z = (H[J][I] + H[J][I+1]) / 2;
  146.           ELSE Z = H[J][I];
  147.  
  148.           /*------- SET ALL NEGATIVE HEIGHTS TO WATER LEVEL -------*/
  149.  
  150.           IF (Z < 0) Z = 0;
  151.           IF ((Z + ZP) == 0) COLOR = ╫┴╘┼╥;
  152.           ELSE COLOR = ╠┴╬─;
  153.           ZP = Z;
  154.  
  155.           /*-------- COMPUTE THE COORDINATES AND PLOT THE -----------
  156.                      LINE SEGMENT.                                 */
  157.  
  158.           EX = X;
  159.           EY = I + I + ODD + Z + 1;
  160.           IF (EY > FMAX) FMAX = EY;
  161.           IF (FIRST)
  162.           █ BX = EX = 1;
  163.             BY = EY;
  164.             FIRST = 0;
  165.           ▌
  166.           IF (I ▀▀ ODD) PLOT(BX, BY, EX, EY);
  167.           BX = EX; 
  168.           BY = EY;
  169.         ▌
  170.         IF (ODD) ODD = 0;
  171.         ELSE ODD = 1;
  172.       ▌
  173.     ▌
  174.     /*------ FILL IN SKY AND THEN WAIT UNTIL ╥┼╘╒╥╬ IS HIT ---------*/
  175.     /* REMOVE HIDDEN LINES UNTIL ABOVE MOUNTAINS */
  176.     COLOR = ╙╦┘;  
  177.     FOR (BY = 129; BY <= FMAX; BY ++) PLOT(1, BY, 315, BY);
  178.  
  179.     /* NOW USE A FAST FILL */
  180.     FOR (BY = 198 - FMAX; BY; BY--)
  181.     █   I = BY & 0XFFF8;
  182.         VPTR = 40960 + (I << 5) + (I << 3) + (BY & 7);
  183.         FOR (X = 0; X < 39; VPTR += 8, X++) *VPTR = 255;
  184.         *VPTR = 248;
  185.     ▌
  186.     WHILE ((C = GETKEY()) != 13);
  187.   ▌
  188.   TEXTMODE(6, 14, 14);
  189.   PRINTF("%C%C%C", 147, 142, 154);
  190. ▌
  191.  
  192.  
  193. /* ╞UNCTION: PLOT 
  194.  *
  195.  *  ╘HIS FUNCTION PLOTS THE LINE SEGMENT(S) WITH HIDDEN LINE REMOVAL 
  196.  */
  197. PLOT(X1, Y1, X2, Y2)
  198. UNSIGNED X1, Y1, X2, Y2;
  199. █
  200.   INT DX, DY, EI, ED, ER, IX, IY, T, SWAP;
  201.   
  202.   /*-------------- COMPUTE DELTA X AND DELTA Y --------------------*/
  203.  
  204.   Y1 = 199 - Y1;
  205.   Y2 = 199 - Y2;
  206.   DX = X2 - X1;
  207.   IF (Y1 < Y2)
  208.   █ T = Y2;
  209.     Y2 = Y1;
  210.     Y1 = T;
  211.     T = X2;
  212.     X2 = X1;
  213.     X1 = T;
  214.     IX = -1;
  215.   ▌
  216.   ELSE IX = 1;
  217.   DY = Y1 - Y2;
  218.   IY = -1;
  219.   SWAP = 0;
  220.   IF (DY > DX)
  221.   █ SWAP = 1;
  222.     T = DX;
  223.     DX = DY;
  224.     DY = T;
  225.   ▌
  226.   /*------------------ COMPUTE ERROR TERMS ------------------------*/
  227.   EI = DY<<1;                  
  228.   ED = (DY - DX)<<1;
  229.   ER = (DY<<1) - DX;
  230.  
  231.   /*------------------ PLOT THE LINE SEGMENT(S) -------------------*/
  232.   FOR (DX++; DX; DX--)
  233.   █ IF (Y1 < MASK[X1])
  234.     █ MASK[X1] = Y1;
  235.       SWITCH (COLOR)
  236.       █ CASE 1: IF (!ODD) PIXEL(X1, Y1);
  237.                 BREAK;
  238.         CASE 2: IF ((X1 & 1) == (Y1 & 1)) PIXEL(X1, Y1);
  239.                 BREAK;
  240.         CASE 3: PIXEL(X1, Y1);
  241.                 BREAK;
  242.       ▌
  243.     ▌
  244.     /*--------- UPDATE THE X OR Y COORDINATE AND ERROR TERM -------*/ 
  245.     IF (SWAP) Y1 += IY;
  246.     ELSE X1 += IX;
  247.     IF (ER < 0) ER += EI;
  248.     ELSE
  249.     █ ER += ED;
  250.       IF (SWAP) X1 += IX;
  251.       ELSE Y1 += IY;
  252.     ▌
  253.   ▌
  254. ▌
  255.  
  256. /* ╞UNCTION: RANDM
  257.  *
  258.  *  ╘HIS FUNCTION RETURNS A RANDOM INTEGER IN THE RANGE
  259.  *  -DELTA+1 TO DELTA-1 INCLUSIVE.
  260.  */
  261. RANDM(DELTA)
  262. INT DELTA;
  263. █
  264.   INT N;
  265.  
  266.   N = RANDOM() & (DELTA - 1);
  267.   RETURN(((RANDOM() & 255) < 127) ? -N : N);
  268. ▌
  269.  
  270. /* ╞UNCTION: HIRES
  271.  *
  272.  * ╘HIS VERSION OF HIRES PUTS THE BITMAP UNDER ┬┴╙╔├ ╥╧═
  273.  * TO GET ENOUGH MEMORY AND STILL HAVE THE PROGRAM ╠╧┴─
  274.  * AND ╙┴╓┼ AS A ┬┴╙╔├ PROGRAM.
  275.  */
  276. HIRES(BACKGRND, FOREGRND, BORDER)
  277. CHAR BACKGRND, FOREGRND, BORDER;
  278. █
  279.     CHAR COLOR, *PTR;
  280.  
  281.     PTR = 53280;
  282.     *PTR = BORDER;
  283.     COLOR = (FOREGRND << 4) ▀ BACKGRND;
  284.     FOR (PTR = 40960; PTR < 48960; PTR++) *PTR = 0;
  285.     FOR (PTR = 35840; PTR < 36840; PTR++) *PTR = COLOR;
  286.     PTR = 1;
  287.     *PTR = *PTR & 254;
  288.     PTR = 56576;
  289.     *PTR = (*PTR & 252) ▀ 1;
  290.     PTR = 53272;
  291.     *PTR = (*PTR & 15) ▀ 48;
  292.     *PTR = (*PTR & 240) ▀ 8;
  293.     PTR = 53265;
  294.     *PTR ▀= 32;
  295.     PTR = 648;
  296.     *PTR = 140;
  297. ▌
  298.  
  299. /* ╞UNCTION: TEXTMODE
  300. */
  301. TEXTMODE(BACKGRND, FOREGRND, BORDER)
  302. CHAR BACKGRND, FOREGRND, BORDER;
  303. █
  304.     CHAR *PTR;
  305.  
  306.     PTR = 1;
  307.     *PTR = *PTR ▀ 1;
  308.     PTR = 53280;
  309.     *PTR++ = BORDER;
  310.     *PTR = BACKGRND;
  311.     FOR (PTR = 1024; PTR < 2024; PTR++) *PTR = 32;
  312.     FOR (PTR = 55296; PTR < 56296; PTR++) *PTR = FOREGRND;
  313.     PTR = 56576;
  314.     *PTR = (*PTR & 252) ▀ 3;
  315.     PTR = 53265;
  316.     *PTR &= 223;
  317.     PTR = 53272;
  318.     *PTR = (*PTR & 15) ▀ 16;
  319.     *PTR = (*PTR & 240) ▀ 4;
  320.     PTR = 648;
  321.     *PTR = 4;
  322. ▌
  323.  
  324. /* ╞UNCTION: PIXEL
  325.  *
  326.  * ╙ETS THE PIXEL AT X,Y
  327.  */
  328. PIXEL(X, Y)
  329. UNSIGNED X, Y;
  330. █
  331.     CHAR *V;
  332.     UNSIGNED TMP;
  333.     STATIC CHAR BITVALS[] = █ 128, 64, 32, 16, 8, 4, 2, 1 ▌;
  334.  
  335.     TMP = Y & 0XFFF8;
  336.     V = 40960 + (TMP << 5) + (TMP << 3) + ((Y & 7) ▀ (X & 0XFFF8));
  337.     *V ▀= BITVALS[X & 7];
  338. ▌
  339.  
  340. /* ╞UNCTION: GETKEY
  341.  *
  342.  * ╫AITS FOR AND RETURNS A KEYPRESS.
  343.  */
  344. CHAR GETKEY()
  345. █
  346.     CHAR A, X, Y;
  347.  
  348.     A = 0;
  349.     WHILE (A == 0) SYS(0XF13E, &A, &X, &Y);
  350.     RETURN A;
  351. ▌
  352.  
  353.